/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import { request as __request, checkJsonSchema as __checkJsonSchema } from '../../core/request';
const schemas = require("../schema").default;

export class DataSetService {

    /**
     * 向指定方案中的指定用例添加测试数据
     * @returns any Example response
     * @throws ApiError
     */
    public static async addTestData({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
            /**
             * 用例ID
             */
            caseId: number,
            /**
             * 需要添加的测试数据集
             */
            data: any,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/datasetdatamanager/v1/addData`,
            body: requestBody,
        });

        __checkJsonSchema("addTestData", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 获取指定方案中指定用例的所有数据集信息
     * @returns any OK
     * @throws ApiError
     */
    public static async getListData({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
            /**
             * 用例ID
             */
            caseId: number,
            /**
             * 分页查询的页数
             * 1）不传该参数，查询内容不分页
             * 2）传大于等于1的整数时，分页查询
             */
            pageNum?: number,
            /**
             * 分页查询的每页数据条数，取值范围 1-100。默认提取20条
             */
            pageDataCount?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 总记录数
         */
        totalDataCount: number,
        /**
         * 当前方案中该用例的测试数据列表
         */
        dataset: Array<{
            /**
             * 数据ID，对应Mongo主键
             */
            id: string,
            /**
             * 一条测试数据
             */
            data: any,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/datasetdatamanager/v1/listData`,
            body: requestBody,
        });

        __checkJsonSchema("getListData", schemas, result);
        return result.body;
    }

    /**
     * 删除指定方案中的指定用例的部分测试数据
     * @returns any Example response
     * @throws ApiError
     */
    public static async deleteTestData({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
            /**
             * 数据ID，对应Mongo主键
             */
            id: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'DELETE',
            path: `/datasetdatamanager/v1/deleteData`,
            body: requestBody,
        });

        __checkJsonSchema("deleteTestData", schemas, result);
        return result.body;
    }

    /**
     * 修改指定方案中的指定用例的某条测试数据
     * @returns any Example response
     * @throws ApiError
     */
    public static async editTestData({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
            /**
             * 数据ID，对应Mongo主键
             */
            id: string,
            /**
             * 需要修改的测试数据
             */
            data: any,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/datasetdatamanager/v1/editData`,
            body: requestBody,
        });

        __checkJsonSchema("editTestData", schemas, result);
        return result.body;
    }

    /**
     * 通过在前端导入合适的csv文件，将该文件中的数据添加到指定方案中的指定用例
     * @returns any Example response
     * @throws ApiError
     */
    public static async importDataDoc({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
            /**
             * 用例ID
             */
            caseId: number,
            /**
             * 需要导入的数据csv文件
             */
            file: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/datasetdatamanager/v1/importData`,
            body: requestBody,
        });

        __checkJsonSchema("importDataDoc", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 下载指定方案中的指定用例的所有数据文件，文件为csv格式
     * @returns any OK
     * @throws ApiError
     */
    public static async exportDataDoc({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
            /**
             * 用例ID
             */
            caseId: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 需要导入的模版csv文件
         */
        file: string,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/datasetdatamanager/v1/exportData`,
            body: requestBody,
        });

        __checkJsonSchema("exportDataDoc", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 获取指定用例的数据集模版内容
     * @returns any OK
     * @throws ApiError
     */
    public static async getDataTemplate({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 用例ID
             */
            caseId: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 用例的数据集模版信息
         */
        template: Array<{
            /**
             * 数据项的名称
             */
            name: string,
            /**
             * 数据类型，可取值：
             * integer – 整型
             * float – 浮点型
             * string – 字符串
             */
            datatype: string,
            /**
             * 数据项的描述
             */
            comment?: string,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/datasettemplatemanager/v1/getTemplate`,
            body: requestBody,
        });

        __checkJsonSchema("getDataTemplate", schemas, result);
        return result.body;
    }

    /**
     * 添加指定用例的数据集模版中的参数
     * @returns any Example response
     * @throws ApiError
     */
    public static async addDataVariable({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 用例ID
             */
            caseId: number,
            /**
             * 需要添加的数据集参数信息
             */
            templateParam: {
                /**
                 * 数据项的名称
                 */
                name: string,
                /**
                 * 数据类型，可取值：
                 * integer – 整型
                 * float – 浮点型
                 * string – 字符串
                 */
                datatype: string,
                /**
                 * 数据项的描述
                 */
                comment?: string,
            },
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/datasettemplatemanager/v1/addVariable`,
            body: requestBody,
        });

        __checkJsonSchema("addDataVariable", schemas, result);
        return result.body;
    }

    /**
     * 添加指定用例的数据集模版中部分参数
     * @returns any Example response
     * @throws ApiError
     */
    public static async deleteDataVariable({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 用例ID
             */
            caseId: number,
            /**
             * 要删除的数据集参数名
             */
            paramName: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'DELETE',
            path: `/datasettemplatemanager/v1/deleteVariable`,
            body: requestBody,
        });

        __checkJsonSchema("deleteDataVariable", schemas, result);
        return result.body;
    }

    /**
     * 通过在前端导入合适的csv文件，将该文件中的模版添加到用例中
     * @returns any Example response
     * @throws ApiError
     */
    public static async importCsv({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 用例ID
             */
            caseId: number,
            /**
             * 需要导入的模版csv文件
             */
            file: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/datasettemplatemanager/v1/import`,
            body: requestBody,
        });

        __checkJsonSchema("importCSV", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 下载选中用例的数据集模版文件，文件为csv格式
     * @returns any OK
     * @throws ApiError
     */
    public static async exportCsv({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 用例ID
             */
            caseId: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 需要导入的模版csv文件
         */
        file: string,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/datasettemplatemanager/v1/export`,
            body: requestBody,
        });

        __checkJsonSchema("exportCSV", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 获取指定方案中的指定用例的数据自动生成规则
     * @returns any OK
     * @throws ApiError
     */
    public static async getRules({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
            /**
             * 用例ID
             */
            caseId: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 用例中不同参数的自动生成数据规则
         */
        rules: Array<{
            /**
             * 数据项的名称
             */
            name: string,
            /**
             * 数据类型，可取值：
             * integer – 整型
             * float – 浮点型
             * string – 字符串
             */
            datatype: string,
            /**
             * 规则类型，可取值：
             * fix – 定值
             * set – 集合
             * randstr – 随机字符串
             * randnum – 随机数
             * stepnum – 其他数字规则即步进
             */
            ruleType: string,
            /**
             * ruleType=fix/set时有效
             */
            value?: string,
            /**
             * randstr类型的规则细节
             */
            randStrRule?: {
                /**
                 * 字串长度
                 */
                len: number,
                /**
                 * 是否包含大写字母，取值：0-不包含，1-包含
                 */
                hasCapital: number,
                /**
                 * 是否包含小写字母，取值：0-不包含，1-包含
                 */
                hasLower: number,
                /**
                 * 是否包含数字，取值：0-不包含，1-包含
                 */
                hasNum: number,
                /**
                 * 是否包含其他符号字符，取值：0-不包含，1-包含
                 */
                otherChar: number,
            },
            /**
             * randnum和stepnum类型的规则细节
             */
            numRule?: {
                /**
                 * 规则类型，取值：othernum – 其他数字生成规则
                 */
                type: string,
                /**
                 * 最小值，整型和浮点型都有可能，故用string
                 */
                min: string,
                /**
                 * 最大值，整型和浮点型都有可能，故用string
                 */
                max: string,
                /**
                 * 步进值，整型和浮点型都有可能，故用string
                 */
                iterval: string,
            },
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/datasetrulemanager/v1/getRules`,
            body: requestBody,
        });

        __checkJsonSchema("getRules", schemas, result);
        return result.body;
    }

    /**
     * 修改指定方案中的指定用例的数据自动生成规则
     * @returns any Example response
     * @throws ApiError
     */
    public static async editRules({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 方案ID
             */
            planId: number,
            /**
             * 用例ID
             */
            caseId: number,
            /**
             * 需要修改的数据生成规则
             */
            rules: Array<{
                /**
                 * 数据项的名称
                 */
                name: string,
                /**
                 * 数据类型，可取值：
                 * integer – 整型
                 * float – 浮点型
                 * string – 字符串
                 */
                datatype: string,
                /**
                 * 规则类型，可取值：
                 * fix – 定值
                 * set – 集合
                 * randstr – 随机字符串
                 * randnum – 随机数
                 * stepnum – 其他数字规则即步进
                 */
                ruleType: string,
                /**
                 * ruleType=fix/set时有效
                 */
                value?: string,
                /**
                 * randstr类型的规则细节
                 */
                randStrRule?: {
                    /**
                     * 字串长度
                     */
                    len: number,
                    /**
                     * 是否包含大写字母，取值：0-不包含，1-包含
                     */
                    hasCapital: number,
                    /**
                     * 是否包含小写字母，取值：0-不包含，1-包含
                     */
                    hasLower: number,
                    /**
                     * 是否包含数字，取值：0-不包含，1-包含
                     */
                    hasNum: number,
                    /**
                     * 是否包含其他字符，取值：0-不包含，1-包含
                     */
                    otherChar: number,
                },
                /**
                 * randnum和stepnum类型的规则细节
                 */
                numRule?: {
                    /**
                     * 规则类型，取值：othernum – 其他数字生成规则
                     */
                    type: string,
                    /**
                     * 最小值，整型和浮点型都有可能，故用string
                     */
                    min: string,
                    /**
                     * 最大值，整型和浮点型都有可能，故用string
                     */
                    max: string,
                    /**
                     * 步进值，整型和浮点型都有可能，故用string
                     */
                    interval: string,
                },
            }>,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/datasetrulemanager/v1/editRules`,
            body: requestBody,
        });

        __checkJsonSchema("editRules", schemas, result);
        return result.body;
    }

}